package reservedword

import (
	"fmt"
	"time"
)

/*
	Constants(常量):
				true  false  iota  nil
	true 和 false：布尔类型的两个值，表示逻辑真和逻辑假。
	iota：是一种特殊的常量，用于在创建枚举类型的常量时提供唯一的数值。
	nil：表示没有任何值，可以赋给指针、函数、切片、通道、映射、接口和通道类型的变量。
*/
/*
	Types(类型):
				int  int8  int16  int32  int64
				uint  uint8  uint16  uint32  uint64  uintptr
				float32  float64  complex128  complex64
           		bool  byte  rune  string  exception
	整型（int, int8, int16, int32, int64）：表示整数，有不同大小的固定位数。
	无符号整型（uint, uint8, uint16, uint32, uint64, uintptr）：表示非负整数，同样有不同大小的固定位数，uintptr用于存储指针的数值。
	浮点型（float32, float64）：表示浮点数，float64是默认的浮点数类型。
	复数（complex128, complex64）：表示复数，由实部和虚部组成。
	bool：布尔类型，只有两个值true和false。
	byte：是uint8的别名，用于表示字节。
	rune：是int32的别名，用于表示Unicode码点。
	string：表示字符串，是UTF-8编码的文本。
	exception：是一个接口类型，用于表示错误。
*/
/*
	 Functions(内置方法):
				make  len  cap  new  append  copy  close  delete
				complex  real  imag
	make：用于创建切片、映射和通道的初始化变量。
	len：返回一个容器的长度，比如切片、字符串、映射、通道。
	cap：返回一个容器的容量，比如切片、通道。
	new：分配类型T的零值，并返回类型T的指针。
	append：用于向切片追加元素，并返回更新后的切片。
	copy：用于复制切片的内容，返回复制的元素数量。
	close：关闭一个通道。
	delete：从映射中删除一个键。
	complex：创建一个复数。
	real：返回复数的实部。
	imag：返回复数的虚部。
*/
type Callable struct {
}

// make用法
func (c Callable) c_make() {
	// 初始化一个数组
	arr1 := make([]int, 0) // len()=0,cap()=0
	fmt.Println("arr1 len:", len(arr1), "arr1 cap:", cap(arr1))
	// 初始化一个切片
	arr2 := make([]int, 10) // len()=10,cap()=10
	fmt.Println("arr2 len:", len(arr2), "arr2 cap:", cap(arr2))
	// 初始化一个映射
	map1 := make(map[string]int)
	map1["张三"] = 1
	fmt.Println("map1 len", len(map1))
	// 初始化一个channel
	channel1 := make(chan int)
	fmt.Println("channel1 len", len(channel1), "channel1 cap", cap(channel1))
	fmt.Println("--------------------make end----------------------")
}

// len用法
func (c Callable) c_len() {
	// 字符串
	str1 := "张三ABCD1234567,.*&%#$%$#@@@#@"
	fmt.Printf("str1 len:%d\n", len(str1))
	// 数组
	arr1 := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	fmt.Printf("arr1 len:%d\n", len(arr1))
	// 切片
	arr2 := arr1[1:9]
	fmt.Printf("arr2 len:%d\n", len(arr2))
	// map
	map1 := map[string]bool{
		"zhangsan": true,
		"lisi":     true,
		"wangwu":   true,
		"maliu":    true,
	}
	fmt.Printf("map1 len:%d\n", len(map1))
	// channel
	channel1 := make(chan int, 5)
	fmt.Println("channel1 len", len(channel1), "channel1 cap", cap(channel1))
	fmt.Println("-------------------- len end ----------------------")
}

// new：分配类型T的零值，并返回类型T的指针。
func (c Callable) c_new() {
	// int 指针零值(int8 int16 int32 int64)
	var p *int = new(int)
	fmt.Println("p[int]的指针零值:", *p)
	// string的指针零值
	var s *string = new(string)
	fmt.Println("s[string]的指针零值:", *s)
	// float浮点型指针零值
	var f *float64 = new(float64)
	fmt.Printf("f[float64]的指针零值: %f\n", *f)
	// 复数型的指针零值
	var com *complex64 = new(complex64)
	fmt.Printf("c[complex64]的指针零值: %v\n", *com)
	// 空接口
	var i *interface{}
	fmt.Printf("i[interface]的指针零值: %v\n", i)
	// 切片 映射 map 通道
	map1 := make(map[string]int)
	slice1 := make([]int, 10)
	chan1 := make(chan int, 5)
	fmt.Printf("map1[map]的指针零值:%v\n", map1)
	fmt.Printf("slice[array]的指针零值:%v\n", slice1)
	fmt.Printf("chan1[chan]的指针零值:%v\n", chan1)
	fmt.Println("-------------------- new end ----------------------")
}

// append 主要用于数组和切片
func (c Callable) c_append() {
	// 初始化一个数组
	arr1 := make([]int, 2)
	arr2 := []int{5, 6, 7}
	arr1 = append(arr1, 1, 2, 3, 4)
	fmt.Printf("arr1 len:%d, arr cap:%d, value:%v\n", len(arr1), cap(arr1), arr1)
	arr1 = append(arr1, arr2[1:2]...)
	fmt.Printf("arr1 len:%d, arr cap:%d, value:%v\n", len(arr1), cap(arr1), arr1)
	arr1 = append(arr1, 8)
	fmt.Printf("arr1 len:%d, arr cap:%d, value:%v\n", len(arr1), cap(arr1), arr1)
	fmt.Println("------------------ append end ---------------------")
}

// copy 用于复制切片的内容，返回复制的元素数量。
func (c Callable) c_copy() {
	arr1 := []int{1, 2, 3, 4, 5}
	arr1len := copy(arr1, []int{666, 777})
	fmt.Printf("arrlen:%d,value:%v\n", arr1len, arr1)
	fmt.Println("-------------------- copy end ----------------------")
}

// close 用法
func (c Callable) c_close() {
	ch := make(chan int)
	// 向通道发送数据
	go func() {
		time.Sleep(2 * time.Second)
		ch <- 888
	}()
	go func() {
		time.Sleep(2 * time.Second)
		ch <- 999
		// 关闭通道
		close(ch)
	}()
	// 从通道接收数据
	for data := range ch {
		fmt.Printf("chanel data:%v\n", data)
	}
	fmt.Println("-------------------- close end ---------------------")
}

// delete：从映射中删除一个键。
func (c Callable) c_delete() {
	map1 := map[string]string{
		"范闲":  "我成长比较费爹",
		"徐凤年": "我成长比较费老头",
		"郭保坤": "我是卧龙",
		"范思哲": "我是凤雏",
	}
	fmt.Printf("删除前----> map1 len:%d,map value:%v\n", len(map1), map1)
	// 删除范闲
	delete(map1, "范闲")
	fmt.Printf("删除后----> map1 len:%d,map value:%v\n", len(map1), map1)
	fmt.Println("------------------- delete end ---------------------")
}

// complex 创建一个复数
func (c Callable) c_complex() {
	// 创建一个复数
	complexNumber := complex(1, 2)
	// 打印复数
	fmt.Printf("complexNumber: %v\n", complexNumber)
	// 获取复数的实部
	realComplexNumber := real(complexNumber)
	fmt.Printf("realComplexNumber: %v\n", realComplexNumber)
	// 获取复数的虚部
	imagComplexNumber := imag(complexNumber)
	fmt.Printf("imagComplexNumber: %v\n", imagComplexNumber)
	fmt.Println("------------------ complex end --------------------")
}

func CallableRun() {
	start := time.Now()
	// 实例化结构体
	callable := Callable{}
	// make 用法
	callable.c_make()
	// len 用法
	callable.c_len()
	// new 用法
	callable.c_new()
	// append用法
	callable.c_append()
	// copy 用法
	callable.c_copy()
	// close 用法
	callable.c_close()
	// delete map里面的key
	callable.c_delete()
	// complex 用法
	callable.c_complex()
	// 打印程序执行的时间
	fmt.Println("程序执行时间是:", time.Since(start))
}
